using System;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("SpectatorManager")]
	public class SpectatorManager : MonoClass
	{
		public struct ReceivedInvite
		{
			public float m_timestamp;
		}

		[Attribute38("SpectatorManager.IntendedSpectateeParty")]
		public class IntendedSpectateeParty : MonoClass
		{
			public IntendedSpectateeParty(IntPtr address, string className)
				: base(address, className)
			{
			}

			public IntendedSpectateeParty(IntPtr address)
				: this(address, "IntendedSpectateeParty")
			{
			}
		}

		[Attribute38("SpectatorManager.PendingSpectatePlayer")]
		public class PendingSpectatePlayer : MonoClass
		{
			public PendingSpectatePlayer(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PendingSpectatePlayer(IntPtr address)
				: this(address, "PendingSpectatePlayer")
			{
			}
		}

		public static int MAX_SPECTATORS_PER_SIDE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "MAX_SPECTATORS_PER_SIDE");

		public static float RECEIVED_INVITE_TIMEOUT_SECONDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "RECEIVED_INVITE_TIMEOUT_SECONDS");

		public static float SENT_INVITE_TIMEOUT_SECONDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "SENT_INVITE_TIMEOUT_SECONDS");

		public static bool SPECTATOR_PARTY_INVITES_USE_RESERVATIONS => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "SPECTATOR_PARTY_INVITES_USE_RESERVATIONS");

		public static float REQUEST_INVITE_TIMEOUT_SECONDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "REQUEST_INVITE_TIMEOUT_SECONDS");

		public static string ALERTPOPUPID_WAITINGFORNEXTGAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "SpectatorManager", "ALERTPOPUPID_WAITINGFORNEXTGAME");

		public static float ENDGAMESCREEN_AUTO_CLOSE_SECONDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "ENDGAMESCREEN_AUTO_CLOSE_SECONDS");

		public static float KICKED_FROM_SPECTATING_BLACKOUT_DURATION_SECONDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "KICKED_FROM_SPECTATING_BLACKOUT_DURATION_SECONDS");

		public bool m_initialized => method_2<bool>("m_initialized");

		public IntendedSpectateeParty m_requestedInvite => method_3<IntendedSpectateeParty>("m_requestedInvite");

		public AlertPopup m_waitingForNextGameDialog => method_3<AlertPopup>("m_waitingForNextGameDialog");

		public PendingSpectatePlayer m_pendingSpectatePlayerAfterLeave => method_3<PendingSpectatePlayer>("m_pendingSpectatePlayerAfterLeave");

		public bool m_isExpectingArriveInGameplayAsSpectator => method_2<bool>("m_isExpectingArriveInGameplayAsSpectator");

		public bool m_isShowingRemovedAsSpectatorPopup => method_2<bool>("m_isShowingRemovedAsSpectatorPopup");

		public static bool IsGameOver => MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "get_IsGameOver", Array.Empty<object>());

		public SpectatorManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public SpectatorManager(IntPtr address)
			: this(address, "SpectatorManager")
		{
		}

		public static SpectatorManager Get()
		{
			return MonoClass.smethod_15<SpectatorManager>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "Get", Array.Empty<object>());
		}

		public static bool IsSpectatorSlotAvailable(BnetGameAccount gameAccount)
		{
			return MonoClass.smethod_11<bool>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "IsSpectatorSlotAvailable", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { gameAccount });
		}

		public static void WaitingForNextGame_AutoLeaveSpectatorMode(object userData)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "SpectatorManager", "WaitingForNextGame_AutoLeaveSpectatorMode", userData);
		}

		public static void DisplayErrorDialog(string header, string body)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "SpectatorManager", "DisplayErrorDialog", header, body);
		}

		public static SpectatorManager CreateInstance()
		{
			return MonoClass.smethod_15<SpectatorManager>(TritonHs.MainAssemblyPath, "", "SpectatorManager", "CreateInstance", Array.Empty<object>());
		}

		public void InitializeConnectedToBnet()
		{
			method_8("InitializeConnectedToBnet");
		}

		public bool IsInSpectableContextWithPlayer(BnetPlayer player)
		{
			return method_10<bool>("IsInSpectableContextWithPlayer", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public bool CanSpectate(BnetPlayer player)
		{
			return method_11<bool>("CanSpectate", new object[1] { player });
		}

		public bool IsInSpectatorMode()
		{
			return method_11<bool>("IsInSpectatorMode", Array.Empty<object>());
		}

		public bool ShouldBeSpectatingInGame()
		{
			return method_11<bool>("ShouldBeSpectatingInGame", Array.Empty<object>());
		}

		public int GetCountSpectatingMe()
		{
			return method_11<int>("GetCountSpectatingMe", Array.Empty<object>());
		}

		public bool IsBeingSpectated()
		{
			return method_11<bool>("IsBeingSpectated", Array.Empty<object>());
		}

		public bool IsInSpectatableGame()
		{
			return method_11<bool>("IsInSpectatableGame", Array.Empty<object>());
		}

		public bool CanAddSpectators()
		{
			return method_11<bool>("CanAddSpectators", Array.Empty<object>());
		}

		public bool HasAnyReceivedInvites()
		{
			return method_11<bool>("HasAnyReceivedInvites", Array.Empty<object>());
		}

		public bool MyGameHasSpectators()
		{
			return method_11<bool>("MyGameHasSpectators", Array.Empty<object>());
		}

		public bool IsSpectatingOpposingSide()
		{
			return method_11<bool>("IsSpectatingOpposingSide", Array.Empty<object>());
		}

		public void SpectatePlayer(BnetPlayer player)
		{
			method_8("SpectatePlayer", player);
		}

		public void HideShownUI()
		{
			method_8("HideShownUI");
		}

		public void SpectatePlayer_RequestInvite_FriendlySide_Timeout(object userData)
		{
			method_8("SpectatePlayer_RequestInvite_FriendlySide_Timeout", userData);
		}

		public void SpectatePlayer_RequestInvite_OpposingSide_Timeout(object userData)
		{
			method_8("SpectatePlayer_RequestInvite_OpposingSide_Timeout", userData);
		}

		public void LeaveSpectatorMode()
		{
			method_8("LeaveSpectatorMode");
		}

		public void InviteToSpectateMe(BnetPlayer player)
		{
			method_8("InviteToSpectateMe", player);
		}

		public void KickSpectator(BnetPlayer player, bool regenerateSpectatorPassword)
		{
			method_8("KickSpectator", player, regenerateSpectatorPassword);
		}

		public void KickSpectator_Internal(BnetPlayer player, bool regenerateSpectatorPassword, bool addToKickList)
		{
			method_8("KickSpectator_Internal", player, regenerateSpectatorPassword, addToKickList);
		}

		public void UpdateMySpectatorInfo()
		{
			method_8("UpdateMySpectatorInfo");
		}

		public bool HandleDisconnectFromGameplay()
		{
			return method_11<bool>("HandleDisconnectFromGameplay", Array.Empty<object>());
		}

		public void OnRealTimeGameOver()
		{
			method_8("OnRealTimeGameOver");
		}

		public void EndCurrentSpectatedGame(bool isLeavingGameplay)
		{
			method_8("EndCurrentSpectatedGame", isLeavingGameplay);
		}

		public void EndSpectatorMode(bool wasKnownSpectating)
		{
			method_8("EndSpectatorMode", wasKnownSpectating);
		}

		public void ClearAllCacheForReset()
		{
			method_8("ClearAllCacheForReset");
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public bool OnFindGameEvent(FindGameEventData eventData, object userData)
		{
			return method_11<bool>("OnFindGameEvent", new object[2] { eventData, userData });
		}

		public void GameState_InitializedEvent(GameState instance, object userData)
		{
			method_8("GameState_InitializedEvent", instance, userData);
		}

		public void GameState_CreateGameEvent(GameState.CreateGamePhase createGamePhase, object userData)
		{
			method_8("GameState_CreateGameEvent", createGamePhase, userData);
		}

		public void AutoSpectateOpposingSide()
		{
			method_8("AutoSpectateOpposingSide");
		}

		public void OnSceneUnloaded(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnSceneUnloaded", prevMode, prevScene, userData);
		}

		public void ShowWaitingForNextGameDialog()
		{
			method_8("ShowWaitingForNextGameDialog");
		}

		public void CloseWaitingForNextGameDialog()
		{
			method_8("CloseWaitingForNextGameDialog");
		}

		public void UpdateWaitingForNextGameDialog()
		{
			method_8("UpdateWaitingForNextGameDialog");
		}

		public string GetWaitingForNextGameDialogText()
		{
			return method_13("GetWaitingForNextGameDialogText");
		}

		public bool OnSceneUnloaded_AwaitingNextGame_DialogProcessCallback(DialogBase dialog, object userData)
		{
			return method_11<bool>("OnSceneUnloaded_AwaitingNextGame_DialogProcessCallback", new object[2] { dialog, userData });
		}

		public void OnSceneUnloaded_AwaitingNextGame_LeaveSpectatorMode(AlertPopup.Response response, object userData)
		{
			method_8("OnSceneUnloaded_AwaitingNextGame_LeaveSpectatorMode", response, userData);
		}

		public void EnterSpectatorMode_OnTransitionPopupHide(TransitionPopup popup)
		{
			method_8("EnterSpectatorMode_OnTransitionPopupHide", popup);
		}

		public void OnSpectatorOpenJoinOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnSpectatorOpenJoinOptionChanged", option, prevValue, existed, userData);
		}

		public void Network_OnSpectatorInviteReceived_ResponseCallback(AlertPopup.Response response, object userData)
		{
			method_8("Network_OnSpectatorInviteReceived_ResponseCallback", response, userData);
		}

		public void Network_OnSpectatorNotifyEvent()
		{
			method_8("Network_OnSpectatorNotifyEvent");
		}

		public void Network_OnSpectatorNotifyEvent_Removed_GoToNextMode(AlertPopup.Response response, object userData)
		{
			method_8("Network_OnSpectatorNotifyEvent_Removed_GoToNextMode", response, userData);
		}

		public void ReceivedInvitation_ExpireTimeout(object userData)
		{
			method_8("ReceivedInvitation_ExpireTimeout", userData);
		}

		public void BnetFriendMgr_OnFriendsChanged(BnetFriendChangelist changelist, object userData)
		{
			method_8("BnetFriendMgr_OnFriendsChanged", changelist, userData);
		}

		public void EndGameScreen_OnTwoScoopsShown(bool shown, EndGameTwoScoop twoScoops)
		{
			method_8("EndGameScreen_OnTwoScoopsShown", shown, twoScoops);
		}

		public void EndGameScreen_OnTwoScoopsShown_AutoClose(object userData)
		{
			method_8("EndGameScreen_OnTwoScoopsShown_AutoClose", userData);
		}

		public void BnetParty_OnLostPartyReference_RemoveKnownCreator(object userData)
		{
			method_8("BnetParty_OnLostPartyReference_RemoveKnownCreator", userData);
		}

		public void OnBnetPlayersChanged(BnetPlayerChangelist changelist, object userData)
		{
			method_8("OnBnetPlayersChanged", changelist, userData);
		}

		public void PruneOldInvites()
		{
			method_8("PruneOldInvites");
		}

		public void ClearAllReceivedInvitations()
		{
			method_8("ClearAllReceivedInvitations");
		}

		public void DeclineAllReceivedInvitations()
		{
			method_8("DeclineAllReceivedInvitations");
		}

		public void RevokeAllSentInvitations()
		{
			method_8("RevokeAllSentInvitations");
		}

		public void ClearAllSentInvitations()
		{
			method_8("ClearAllSentInvitations");
		}

		public void ClearAllGameServerKnownSpectators()
		{
			method_8("ClearAllGameServerKnownSpectators");
		}

		public void UpdateSpectatorPresence()
		{
			method_8("UpdateSpectatorPresence");
		}

		public void SpectatorManager_UpdatePresenceNextFrame(object userData)
		{
			method_8("SpectatorManager_UpdatePresenceNextFrame", userData);
		}

		public void UpdateSpectatorPartyServerInfo()
		{
			method_8("UpdateSpectatorPartyServerInfo");
		}

		public bool CreatePartyIfNecessary()
		{
			return method_11<bool>("CreatePartyIfNecessary", Array.Empty<object>());
		}

		public void ReinviteKnownSpectatorsNotInParty()
		{
			method_8("ReinviteKnownSpectatorsNotInParty");
		}

		public void LeaveGameScene()
		{
			method_8("LeaveGameScene");
		}
	}
}
